<selfBalancingSkipList>

	selfBalancingSkipList is a data structure that is probably as fast as heapQueue, works in the same quantity and size of arrays, and is totally sorted on average at all times.

	This skipList could be doubly-linked, but only singly-linked is necessary.
	Singly-linked takes less memory, but doubly-linked (including 2 optimize int arrays[]) is probably faster.
	It can be traversed backward in n*log(n) time, and traversed forward in n time.

	This is about the singly-linked version:

	It has 3 arrays:
	int optimize[] //points into value[]. Changes often. Points at some flo value that could be less, could be more, probably is much more.
	int next[] //points into value[]. Points at the next highest flo value
	flo value[] //values change but indexs do not
	//int next[] contains all except 1 of the ints between 0 and next.length-1.
	//Should the highest point at the lowest to form a circle? The lowest could be found by searching for the highest.
	//int optimize[] should, on average, change to point at a higher value, so finding the highest flo is easier.

	The optimize[] int array usually changes when a flo is searched for, and maybe when a flo changes value and moves.
	To look up a flo, start at some flo and recursively branch as a binary tree into the next[] and optimize[] arrays.
	While branching, keep only the flos that are closer to the target flo than previous best matches.
	It is necessary to keep multiple branches open simultaneously because the optimze[] array is useful on average but partially random at the small scale. It is partially random because when a flo moves, its optimize[] int(s) do not have to change.

	In a doubly-linked selfBalancingSkipList, there are 2 next[] and at least 2 optimize[] int arrays.
	There could, for example, be 6 optimize[] int arrays with 3 different target sizes.
	For example, in a selfBalancingSkipList size 1000000,
	the 3 optimize[] ints for each flo could average 16, 256, and 4096 distance in the linked-list.
	The next[] array always averages 1, so its really 1, 16, 256, and 4096.
	There appears to be a gap between 4096 and 1000000 thats bigger than the other gaps,
	but it should be filled by random guessing when a search starts.

	Example search in selfBalancingSkipList size 1000000 with target int sizes 1, 16, 256, and 4096:
	Choose 16 random flos. Maybe choose 1 random index i from 0 to 65536
	and choose all i+65536*c where c ranges 0 to 15.
	Of those 16, choose the closest flo to the target and branch from there.
	Search (or branch) only when the current flo is farther from the target than the previous flo.
	Search (or branch) until find a flo that is past the target flo or until searched 50 flos in this step.
	This step should average approximately 16 searches.
	Repeat this for the 256 and 16 target linked list distances.
	Search linearly until find the exact target flo or verify its not there.
	The whole search averages approximately 16*5=80 iterations, and has worst case of linear search.

	All that can be done with 4 singly-linked lists in 4 int arrays and 1 flo array.

	selfBalancingSkipList searches a constant time slower than a tree and is constant time faster to modify.

	It becomes slower if we use only 1 optimize int array (and 1 linked list int array).

	One way is to choose a quantity of target sizes. Example: 8.
	Each linked list node is 2 ints (next and optimize) and a flo
	and is at some index in 2 int arrays and 1 flo array (the same index in all 3).
	At each index, calculate index&7 to get which of the 8 target optimize sizes to use.
	Each index has only 1 target size. To get a different target size, traverse to an index where index&7 is different.
	Example: Target size = 4 << ((index&7) << 1); //Target size = (int)Math.pow(4., 1.+index%8);
	Knowing the target size of specific indexs does not lets us branch better on average,
	but it would if we could predict what the next index&7 would be.

	Probably an AVL tree, implemented as a few int arrays and a flo array of data, would be faster than this approximate stuff,
	and would have an average depth 30 and maximum depth 40 for a data size 1000000,
	while a selfBalancingSkipList would average 80.

</selfBalancingSkipList>